home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc32 / mcfstd.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-06  |  30.1 KB  |  590 lines
  1. /*  MCFstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "fComplex"
  5.   (single-precision complex numbers)
  6.  
  7.   Copyright (c) 1996-1999 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MATLIB_H )
  12.    #include <MatLib.h>
  13. #endif
  14. #if !defined( __VCFSTD_H )
  15.    #include <VCFstd.h>
  16. #endif
  17.  
  18. #ifdef __cplusplus
  19. extern "C" {
  20. #endif
  21.  
  22. /*************   Dynamic Generation of Matrices   ************************/
  23.  
  24. cfMatrix __vf  MCF_matrix(  unsigned ht, unsigned len );
  25. cfMatrix __vf  MCF_matrix0( unsigned ht, unsigned len );
  26.     /*  notice that, in the memory model HUGE,
  27.         neither len nor ht may exceed 4095            */
  28.  
  29. /***************************************************************************
  30.  *  The following definitions ensure compatibility between dynamically     *
  31.  *  and statically allocated matrices. The definitions are somewhat        *
  32.  *  cumbersome, but the result for you is that you need not care about     *
  33.  *  the differences between the two types.                                 *
  34.  *  (Internally, the address of the first element of any matrix is needed; *
  35.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  36.  *  but yields in either case the correct address to be passed to the      *
  37.  *  function you wish to call.)                                            *
  38.  *  Only in the rare case that you need to pass the address of one of      *
  39.  *  these functions as an argument to another function, you have to use    *
  40.  *  the actual run-time functions defined further below. Be careful with   *
  41.  *  this: future development of compilers may allow us to avoid this un-   *
  42.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  43.  *  use these run-time names.                                              *
  44.  ***************************************************************************/
  45.  
  46.  
  47. /***  Addressing single elements of dynamically allocated matrices: ******
  48.      These two functions are for compatibility with Pascal
  49.      (where elements of dynamically allocated matrices are not directly
  50.      accessible), and for getting around the pointer arithmetics bug in
  51.      some versions of Borland C++.                                     */
  52.  
  53. #define MCF_Pelement( MA, ht, len, m, n ) MCFPelement( MA[0], ht, len, m, n )
  54.                      /* returns a pointer to MA[m][n]. */
  55. #define MCF_element( MA, ht, len, m, n ) *MCFPelement( MA[0], ht, len, m, n )
  56.                      /* dereferenced pointer */
  57.  
  58.  /****************  Initialization  ***************************************
  59.  
  60.     To initialize all elements of a matrix with the same value,
  61.     or to perform arithmetic operations on all elements simultaneously,
  62.     refer to the functions of VectorLib, declared in <VCFstd.h>, <VCFmath.h>.
  63.     In order to use the VectorLib functions, utilize the feature that
  64.     the whole matrix occupies one contiguous area in memory: pass the
  65.     address of the first row to the desired vector function, the size
  66.     of the "vector" being len * ht.
  67.     For example, initialize all elements of the matrix MA with {1.0, 0.0}
  68.     (this is *NOT* the identity matrix)  by calling
  69.         VCF_equ1( MA[0], len * ht );
  70. */
  71.  
  72. #define MCF_equ1( MA, len )                MCFequ1( MA[0], len )
  73.                        /* this is the identity matrix */
  74. #define MCF_outerprod( MA, X, Y, ht, len ) MCFouterprod( MA[0], X, Y, ht, len )
  75.                        /* sizX=ht, sizY=len */
  76. #define MCF_Row_equC( MA, ht, len, iRow, C ) \
  77.                                         MCFRow_equC( MA[0], ht, len, iRow, C )
  78. #define MCF_Col_equC( MA, ht, len, iCol, C ) \
  79.                                         MCFCol_equC( MA[0], ht, len, iCol, C )
  80. #define MCF_Dia_equC( MA, len, C )       MCFDia_equC( MA[0], len, C )
  81.  
  82. #define MCF_Row_equV( MA, ht, len, iRow, X ) \
  83.                                         MCFRow_equV( MA[0], ht, len, iRow, X )
  84. #define MCF_Col_equV( MA, ht, len, iCol, X ) \
  85.                                         MCFCol_equV( MA[0], ht, len, iCol, X )
  86. #define MCF_Dia_equV( MA, len, X )       MCFDia_equV( MA[0], len, X )
  87.  
  88. #define MCF_equM( MB, MA, ht, len )  VCF_equV( MB[0], MA[0], ((ui)(len))*(ht) )
  89.  
  90. #define MCF_UequL( MA, len ) MCFUequL( MA[0], len )
  91. #define MCF_LequU( MA, len ) MCFLequU( MA[0], len )
  92.          /* copy lower-diagonal elements into upper-diagonal
  93.            (or vice versa) by index-reflection, so as to
  94.            get a symmetric matrix    */
  95.  
  96.             /* data-type conversions:  */
  97. #define M_CEtoCF( MCF, MCE, ht, len ) V_CEtoCF( MCF[0], MCE[0], ((ui)ht)*len )
  98. #define M_CFtoCE( MCE, MCF, ht, len ) V_CFtoCE( MCE[0], MCF[0], ((ui)ht)*len )
  99. #define M_CDtoCF( MCF, MCD, ht, len ) V_CDtoCF( MCF[0], MCD[0], ((ui)ht)*len )
  100. #define M_CFtoCD( MCD, MCF, ht, len ) V_CFtoCD( MCD[0], MCF[0], ((ui)ht)*len )
  101.  
  102. /********  Extracting a submatrix and copying a submatrix back  *********/
  103.  
  104. #define MCF_submatrix( MSub, subHt, subLen, \
  105.                        MSrce, srceHt, srceLen, \
  106.                        firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  107.                MCFsubmatrix(  MSub[0], subHt, subLen, \
  108.                               MSrce[0], srceHt, srceLen, \
  109.                               firstRowInCol, sampInCol, firstColInRow, sampInRow )
  110.  
  111. #define MCF_submatrix_equM( MDest, destHt, destLen, \
  112.                             firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  113.                             MSrce, srceHt, srceLen ) \
  114.                MCFsubmatrix_equM(  MDest[0], destHt, destLen, \
  115.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  116.                              MSrce[0], srceHt, srceLen )
  117.  
  118. /*****   Extracting a single row or a single column or the diagonal  ******
  119.  *       and storing it into a vector                                     */
  120.  
  121. #define MCF_Row_extract( Y, MA, ht, len, iRow ) \
  122.                                      MCFRow_extract( Y, MA[0], ht, len, iRow )
  123. #define MCF_Col_extract( Y, MA, ht, len, iCol ) \
  124.                                      MCFCol_extract( Y, MA[0], ht, len, iCol )
  125. #define MCF_Dia_extract( Y, MA, len ) MCFDia_extract( Y, MA[0], len )
  126.  
  127.  
  128. /*****************    Basic arithmetic operations *********************
  129.                       performed on one single row,
  130.                       or one single column of any matrix,
  131.                       or on the diagonal of a square matrix
  132.  
  133.     Note: In contrast to the analogous VectorLib functions, the operations
  134.     are performed in-place, i.e. the input matrix itself is changed  */
  135.  
  136. #define MCF_Row_addC( MA, ht, len, iRow, C ) \
  137.                                      MCFRow_addC( MA[0], ht, len, iRow, C )
  138. #define MCF_Col_addC( MA, ht, len, iCol, C ) \
  139.                                      MCFCol_addC( MA[0], ht, len, iCol, C )
  140. #define MCF_Dia_addC( MA, len, C )   MCFDia_addC( MA[0], len, C )
  141.  
  142. #define MCF_Row_addV( MA, ht, len, iRow, X ) \
  143.                                      MCFRow_addV( MA[0], ht, len, iRow, X )
  144. #define MCF_Col_addV( MA, ht, len, iCol, X ) \
  145.                                      MCFCol_addV( MA[0], ht, len, iCol, X )
  146. #define MCF_Dia_addV( MA, len, X )   MCFDia_addV( MA[0], len, X )
  147.  
  148. #define MCF_Row_subC( MA, ht, len, iRow, C ) \
  149.                                      MCFRow_addC( MA[0], ht, len, iRow, (-C) )
  150. #define MCF_Col_subC( MA, ht, len, iCol, C ) \
  151.                                      MCFCol_addC( MA[0], ht, len, iCol, (-C) )
  152. #define MCF_Dia_subC( MA, len, C )   MCFDia_addC( MA[0], len, (-C) )
  153.  
  154. #define MCF_Row_subV( MA, ht, len, iRow, X ) \
  155.                                      MCFRow_subV( MA[0], ht, len, iRow, X )
  156. #define MCF_Col_subV( MA, ht, len, iCol, X ) \
  157.                                      MCFCol_subV( MA[0], ht, len, iCol, X )
  158. #define MCF_Dia_subV( MA, len, X )   MCFDia_subV( MA[0], len, X )
  159.  
  160. #define MCF_Row_subrC( MA, ht, len, iRow, C ) \
  161.                                      MCFRow_subrC( MA[0], ht, len, iRow, C )
  162. #define MCF_Col_subrC( MA, ht, len, iCol, C ) \
  163.                                      MCFCol_subrC( MA[0], ht, len, iCol, C )
  164. #define MCF_Dia_subrC( MA, len, C )  MCFDia_subrC( MA[0], len, C )
  165.  
  166. #define MCF_Row_subrV( MA, ht, len, iRow, X ) \
  167.                                      MCFRow_subrV( MA[0], ht, len, iRow, X )
  168. #define MCF_Col_subrV( MA, ht, len, iCol, X ) \
  169.                                      MCFCol_subrV( MA[0], ht, len, iCol, X )
  170. #define MCF_Dia_subrV( MA, len, X )  MCFDia_subrV( MA[0], len, X )
  171.  
  172. #define MCF_Row_mulC( MA, ht, len, iRow, C ) \
  173.                                      MCFRow_mulC( MA[0], ht, len, iRow, C )
  174. #define MCF_Col_mulC( MA, ht, len, iCol, C ) \
  175.                                      MCFCol_mulC( MA[0], ht, len, iCol, C )
  176. #define MCF_Dia_mulC( MA, len, C )   MCFDia_mulC( MA[0], len, C )
  177.  
  178. #define MCF_Row_mulV( MA, ht, len, iRow, X ) \
  179.                                      MCFRow_mulV( MA[0], ht, len, iRow, X )
  180. #define MCF_Col_mulV( MA, ht, len, iCol, X ) \
  181.                                      MCFCol_mulV( MA[0], ht, len, iCol, X )
  182. #define MCF_Dia_mulV( MA, len, X )   MCFDia_mulV( MA[0], len, X )
  183.  
  184. #define MCF_Row_divC( MA, ht, len, iRow, C ) \
  185.                                      MCFRow_divC( MA[0], ht, len, iRow, C )
  186. #define MCF_Col_divC( MA, ht, len, iCol, C ) \
  187.                                      MCFCol_divC( MA[0], ht, len, iCol, C )
  188. #define MCF_Dia_divC( MA, len, C )   MCFDia_divC( MA[0], len, C )
  189.  
  190. #define MCF_Row_divV( MA, ht, len, iRow, X ) \
  191.                                       MCFRow_divV( MA[0], ht, len, iRow, X )
  192. #define MCF_Col_divV( MA, ht, len, iCol, X ) \
  193.                                       MCFCol_divV( MA[0], ht, len, iCol, X )
  194. #define MCF_Dia_divV( MA, len, X )    MCFDia_divV( MA[0], len, X )
  195.  
  196. #define MCF_Row_divrC( MA, ht, len, iRow, C ) \
  197.                                       MCFRow_divrC( MA[0], ht, len, iRow, C )
  198. #define MCF_Col_divrC( MA, ht, len, iCol, C ) \
  199.                                       MCFCol_divrC( MA[0], ht, len, iCol, C )
  200. #define MCF_Dia_divrC( MA, len, C )   MCFDia_divrC( MA[0], len, C )
  201.  
  202. #define MCF_Row_divrV( MA, ht, len, iRow, X ) \
  203.                                       MCFRow_divrV( MA[0], ht, len, iRow, X )
  204. #define MCF_Col_divrV( MA, ht, len, iCol, X ) \
  205.                                       MCFCol_divrV( MA[0], ht, len, iCol, X )
  206. #define MCF_Dia_divrV( MA, len, X )   MCFDia_divrV( MA[0], len, X )
  207.  
  208.  
  209. /******  One-dimensional vector operations **********************
  210.          performed along all rows or all columns simultaneously,
  211.          or along the diagonal of a square matrix                */
  212.  
  213. #define MCF_Rows_absmax( Y, MA, ht, len )  MCFRows_absmax( Y, MA[0], ht, len )
  214. #define MCF_Cols_absmax( Y, MA, ht, len )  MCFCols_absmax( Y, MA[0], ht, len )
  215. #define MCF_Dia_absmax( MA, len )          MCFDia_absmax( MA[0], len )
  216. #define MCF_Rows_absmin( Y, MA, ht, len )  MCFRows_absmin( Y, MA[0], ht, len )
  217. #define MCF_Cols_absmin( Y, MA, ht, len )  MCFCols_absmin( Y, MA[0], ht, len )
  218. #define MCF_Dia_absmin( MA, len )          MCFDia_absmin( MA[0], len )
  219.  
  220. #define MCF_Rows_maxReIm( Y, MA, ht, len ) MCFRows_maxReIm( Y, MA[0], ht, len )
  221. #define MCF_Cols_maxReIm( Y, MA, ht, len ) MCFCols_maxReIm( Y, MA[0], ht, len )
  222. #define MCF_Dia_maxReIm( MA, len )         MCFDia_maxReIm( MA[0], len )
  223. #define MCF_Rows_minReIm( Y, MA, ht, len ) MCFRows_minReIm( Y, MA[0], ht, len )
  224. #define MCF_Cols_minReIm( Y, MA, ht, len ) MCFCols_minReIm( Y, MA[0], ht, len )
  225. #define MCF_Dia_minReIm( MA, len )         MCFDia_minReIm( MA[0], len )
  226.  
  227. #define MCF_Rows_absmaxReIm( Y, MA, ht, len ) MCFRows_absmaxReIm( Y, MA[0], ht, len )
  228. #define MCF_Cols_absmaxReIm( Y, MA, ht, len ) MCFCols_absmaxReIm( Y, MA[0], ht, len )
  229. #define MCF_Dia_absmaxReIm( MA, len )         MCFDia_absmaxReIm( MA[0], len )
  230. #define MCF_Rows_absminReIm( Y, MA, ht, len ) MCFRows_absminReIm( Y, MA[0], ht, len )
  231. #define MCF_Cols_absminReIm( Y, MA, ht, len ) MCFCols_absminReIm( Y, MA[0], ht, len )
  232. #define MCF_Dia_absminReIm( MA, len )         MCFDia_absminReIm( MA[0], len )
  233.  
  234. #define MCF_Rows_sum( Y, MA, ht, len )     MCFRows_sum( Y, MA[0], ht, len )
  235. #define MCF_Cols_sum( Y, MA, ht, len )     MCFCols_sum( Y, MA[0], ht, len )
  236. #define MCF_Dia_sum(  MA, len )            MCFDia_sum( MA[0], len )
  237. #define MCF_Rows_prod( Y, MA, ht, len )    MCFRows_prod( Y, MA[0], ht, len )
  238. #define MCF_Cols_prod( Y, MA, ht, len )    MCFCols_prod( Y, MA[0], ht, len )
  239. #define MCF_Dia_prod(  MA, len )           MCFDia_prod( MA[0], len )
  240.  
  241. #define MCF_Rows_runsum( MA, ht, len )     MCFRows_runsum( MA[0], ht, len )
  242. #define MCF_Cols_runsum( MA, ht, len )     MCFCols_runsum( MA[0], ht, len )
  243. #define MCF_Rows_runprod( MA, ht, len )    MCFRows_runprod( MA[0], ht, len )
  244. #define MCF_Cols_runprod( MA, ht, len )    MCFCols_runprod( MA[0], ht, len )
  245.  
  246. #define MCF_Rows_rotate( MA, ht, len, pos) MCFRows_rotate( MA[0], ht, len, pos )
  247. #define MCF_Cols_rotate( MA, ht, len, pos) MCFCols_rotate( MA[0], ht, len, pos )
  248.  
  249. /********  Operations involving two rows or two colums of one matrix  *****/
  250.  
  251. #define MCF_Rows_exchange( MA, ht, len, row1, row2 ) \
  252.                              MCFRows_exchange( MA[0], ht, len, row1, row2 )
  253. #define MCF_Cols_exchange( MA, ht, len, col1, col2 ) \
  254.                              MCFCols_exchange( MA[0], ht, len, col1, col2 )
  255.  
  256. #define MCF_Rows_add( MA, ht, len, destRow, srceRow ) \
  257.                              MCFRows_add( MA[0], ht, len, destRow, srceRow )
  258. #define MCF_Cols_add( MA, ht, len, destCol, srceCol ) \
  259.                              MCFCols_add( MA[0], ht, len, destCol, srceCol )
  260.                          /* dest[i] += source[i]  */
  261.  
  262. #define MCF_Rows_sub( MA, ht, len, destRow, srceRow ) \
  263.                              MCFRows_sub( MA[0], ht, len, destRow, srceRow )
  264. #define MCF_Cols_sub( MA, ht, len, destCol, srceCol ) \
  265.                              MCFCols_sub( MA[0], ht, len, destCol, srceCol )
  266.                          /* dest[i] -= source[i]  */
  267.  
  268. #define MCF_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  269.                           MCFRows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  270. #define MCF_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  271.                           MCFCols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  272.                          /* dest[i] += C * source[i]  */
  273.  
  274. #define MCF_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  275.             MCFRows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  276. #define MCF_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  277.             MCFCols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  278.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  279.  
  280.  
  281. /*************************  Transposing a matrix **********************/
  282.  
  283. #define MCF_transpose( MTr, MA, htTr, lenTr ) \
  284.              MCFtranspose( MTr[0], MA[0], htTr, lenTr )
  285.        /*  the dimensions htTr, lenTr are those of the transposed matrix,
  286.            not of the original!                */
  287.  
  288.  
  289. /************************ Matrix Multiplication *************************/
  290.  
  291. #define MCF_mulV( Y, MA, X, htA, lenA ) \
  292.                     MCFmulV( Y, MA[0], X, htA, lenA )
  293.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  294.                               both X and Y are column-vectors    */
  295. #define VCF_mulM( Y, X, MA, sizX, lenA ) \
  296.                     VCFmulM( Y, X, MA[0], 1, sizX, lenA )
  297.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  298.                              both X and Y are row-vectors.
  299.                              Mind the prefix: VCF_ (not MCF_)    */
  300. #define MCF_mulM( MC, MA, MB, htA, lenA, lenB ) \
  301.                     MCFmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  302.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  303.  
  304.  
  305. /***************** Two-Dimensional Fourier-Transform Methods ************/
  306.  
  307. #define MCFl_FFT( MY, MX, ht, len, dir )     MCFlFFT( MY[0], MX[0], ht, len, dir )
  308. #define MCFl_filter( MY, MX, MFlt, ht, len ) MCFlfilter( MY[0], MX[0], MFlt[0], ht, len )
  309.  
  310. #define MCFs_FFT( MY, MX, ht, len, dir )     MCFsFFT( MY[0], MX[0], ht, len, dir )
  311. #define MCFs_filter( MY, MX, MFlt, ht, len ) MCFsfilter( MY[0], MX[0], MFlt[0], ht, len )
  312.  
  313. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  314.    #define MCF_FFT         MCFl_FFT
  315.    #define MCF_filter      MCFl_filter
  316. #else
  317.    #define MCF_FFT         MCFs_FFT
  318.    #define MCF_filter      MCFs_filter
  319. #endif
  320.  
  321. /**************************  Input and Output  **************************/
  322.  
  323. #define MCF_fprint( stream, MA, ht, len, linewidth ) \
  324.                     MCFfprint( stream, MA[0], ht, len, linewidth )
  325. #define MCF_print( MA, ht, len )  MCFfprint( stdout, MA[0], ht, len, 80 )
  326. #define MCF_cprint( MA, ht, len ) MCFcprint( MA[0], ht, len )
  327.   /*  MCF_print, MCF_cprint usable only for DOS, EasyWin, and Win32 console applications! */
  328.  
  329. #define MCF_write( str, MA, ht, len )   MCFwrite( str, MA[0], ht, len )
  330. #define MCF_read( MA, ht, len, str )    MCFread( MA[0], ht, len, str )
  331. #define MCF_setWriteFormat              VCF_setWriteFormat
  332. #define MCF_setWriteSeparate            VCF_setNWriteSeparate
  333.                                    /* write and read in ascii format */
  334. #define MCF_store( str, MA, ht, len ) \
  335.                            VCF_store( str, MA[0], ((ui)(len))*(ht) );
  336. #define MCF_recall( MA, ht, len, str) \
  337.                            VCF_recall( MA[0], ((ui)(len))*(ht), str);
  338.                                   /* store and recall in binary format */
  339.  
  340.  
  341. /*************************************************************************
  342.  * Here are now the actual declarations of the functions used internally.*
  343.  * These declarations may change in future versions of MatrixLib!        *
  344.  * You should not care too much about them, except in the case you need  *
  345.  * the actual address of a run-time function (see above). Under all      *
  346.  * "normal" circumstances, use only the names defined above in the       *
  347.  * macro section!                                                        *
  348.  *************************************************************************/
  349.  
  350. fComplex _VFAR * MCFPelement( cfPMatrix X, unsigned ht, unsigned len,
  351.                               unsigned m, unsigned n );
  352.                   /* pointer is normalized in memory model HUGE */
  353.  
  354. void   __vf  MCFequ1( cfPMatrix MA, unsigned len );  /* identity matrix */
  355. void   __vf  MCFouterprod( cfPMatrix MA, cfVector X,  cfVector Y,
  356.                            unsigned ht, unsigned len );
  357.  
  358. void   __vf  MCFRow_equC( cfPMatrix MA, unsigned ht, unsigned len,
  359.                          unsigned iRow, fComplex C );
  360. void   __vf  MCFCol_equC( cfPMatrix MA, unsigned ht, unsigned len,
  361.                          unsigned iCol, fComplex C );
  362. void   __vf  MCFDia_equC( cfPMatrix MA, unsigned len, fComplex C );
  363.  
  364. void   __vf  MCFRow_equV( cfPMatrix MA, unsigned ht, unsigned len,
  365.                          unsigned iRow, cfVector X );
  366. void   __vf  MCFCol_equV( cfPMatrix MA, unsigned ht, unsigned len,
  367.                          unsigned iCol, cfVector X );
  368. void   __vf  MCFDia_equV( cfPMatrix MA, unsigned len, cfVector X );
  369.  
  370. void   __vf  MCFUequL( cfPMatrix MA, unsigned len );
  371. void   __vf  MCFLequU( cfPMatrix MA, unsigned len );
  372.  
  373. /********  Extracting a submatrix and copying a submatrix back  *********/
  374.  
  375. void  __vf  MCFsubmatrix( cfPMatrix MSub,
  376.                           unsigned subHt,  unsigned subLen,
  377.                           cfPMatrix MSrce,
  378.                           unsigned srceHt,  unsigned srceLen,
  379.                           unsigned firstRowInCol,  unsigned sampInCol,
  380.                           unsigned firstColInRow,  unsigned sampInRow );
  381.  
  382. void  __vf  MCFsubmatrix_equM( cfPMatrix MDest,
  383.                                unsigned destHt,     unsigned destLen,
  384.                                unsigned firstRowInCol,  unsigned sampInCol,
  385.                                unsigned firstColInRow,  unsigned sampInRow,
  386.                                cfPMatrix MSrce,
  387.                                unsigned srceHt,     unsigned srceLen );
  388.  
  389.  
  390. /*****   Extracting a single row or a single column or the diagonal  *****
  391.  *       and storing it into a vector                                    */
  392.  
  393. void __vf MCFRow_extract( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len,
  394.                            unsigned iRow );
  395. void __vf MCFCol_extract( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len,
  396.                            unsigned iCol );
  397. void __vf MCFDia_extract( cfVector Y, cfPMatrix MA, unsigned len );
  398.  
  399.  
  400. /*****************    Basic arithmetic operations ***********************
  401.      performed on one single row,  or one single column of any matrix,
  402.      or on the diagonal of a square matrix                              */
  403.  
  404. void   __vf  MCFRow_addC( cfPMatrix MA, unsigned ht, unsigned len,
  405.                          unsigned iRow, fComplex C );
  406. void   __vf  MCFCol_addC( cfPMatrix MA, unsigned ht, unsigned len,
  407.                          unsigned iCol, fComplex C );
  408. void   __vf  MCFDia_addC( cfPMatrix MA, unsigned len, fComplex C );
  409.  
  410. void   __vf  MCFRow_subC( cfPMatrix MA, unsigned ht, unsigned len,
  411.                          unsigned iRow, fComplex C );
  412. void   __vf  MCFCol_subC( cfPMatrix MA, unsigned ht, unsigned len,
  413.                          unsigned iCol, fComplex C );
  414. void   __vf  MCFDia_subC( cfPMatrix MA, unsigned len, fComplex C );
  415.  
  416. void   __vf  MCFRow_addV( cfPMatrix MA, unsigned ht, unsigned len,
  417.                          unsigned iRow, cfVector X );
  418. void   __vf  MCFCol_addV( cfPMatrix MA, unsigned ht, unsigned len,
  419.                          unsigned iCol, cfVector X );
  420. void   __vf  MCFDia_addV( cfPMatrix MA, unsigned len, cfVector X );
  421.  
  422. void   __vf  MCFRow_subV( cfPMatrix MA, unsigned ht, unsigned len,
  423.                          unsigned iRow, cfVector X );
  424. void   __vf  MCFCol_subV( cfPMatrix MA, unsigned ht, unsigned len,
  425.                          unsigned iCol, cfVector X );
  426. void   __vf  MCFDia_subV( cfPMatrix MA, unsigned len, cfVector X );
  427.  
  428. void   __vf  MCFRow_subrC( cfPMatrix MA, unsigned ht, unsigned len,
  429.                          unsigned iRow, fComplex C );
  430. void   __vf  MCFCol_subrC( cfPMatrix MA, unsigned ht, unsigned len,
  431.                          unsigned iCol, fComplex C );
  432. void   __vf  MCFDia_subrC( cfPMatrix MA, unsigned len, fComplex C );
  433.  
  434. void   __vf  MCFRow_subrV( cfPMatrix MA, unsigned ht, unsigned len,
  435.                          unsigned iRow, cfVector X );
  436. void   __vf  MCFCol_subrV( cfPMatrix MA, unsigned ht, unsigned len,
  437.                          unsigned iCol, cfVector X );
  438. void   __vf  MCFDia_subrV( cfPMatrix MA, unsigned len, cfVector X );
  439.  
  440. void   __vf  MCFRow_mulC( cfPMatrix MA, unsigned ht, unsigned len,
  441.                          unsigned iRow, fComplex C );
  442. void   __vf  MCFCol_mulC( cfPMatrix MA, unsigned ht, unsigned len,
  443.                          unsigned iCol, fComplex C );
  444. void   __vf  MCFDia_mulC( cfPMatrix MA, unsigned len, fComplex C );
  445.  
  446. void   __vf  MCFRow_mulV( cfPMatrix MA, unsigned ht, unsigned len,
  447.                          unsigned iRow, cfVector X );
  448. void   __vf  MCFCol_mulV( cfPMatrix MA, unsigned ht, unsigned len,
  449.                          unsigned iCol, cfVector X );
  450. void   __vf  MCFDia_mulV( cfPMatrix MA, unsigned len, cfVector X );
  451.  
  452. void   __vf  MCFRow_divC( cfPMatrix MA, unsigned ht, unsigned len,
  453.                          unsigned iRow, fComplex C );
  454. void   __vf  MCFCol_divC( cfPMatrix MA, unsigned ht, unsigned len,
  455.                          unsigned iCol, fComplex C );
  456. void   __vf  MCFDia_divC( cfPMatrix MA, unsigned len, fComplex C );
  457.  
  458. void   __vf  MCFRow_divV( cfPMatrix MA, unsigned ht, unsigned len,
  459.                          unsigned iRow, cfVector X );
  460. void   __vf  MCFCol_divV( cfPMatrix MA, unsigned ht, unsigned len,
  461.                          unsigned iCol, cfVector X );
  462. void   __vf  MCFDia_divV( cfPMatrix MA, unsigned len, cfVector X );
  463.  
  464. void   __vf  MCFRow_divrC( cfPMatrix MA, unsigned ht, unsigned len,
  465.                          unsigned iRow, fComplex C );
  466. void   __vf  MCFCol_divrC( cfPMatrix MA, unsigned ht, unsigned len,
  467.                          unsigned iCol, fComplex C );
  468. void   __vf  MCFDia_divrC( cfPMatrix MA, unsigned len, fComplex C );
  469.  
  470. void   __vf  MCFRow_divrV( cfPMatrix MA, unsigned ht, unsigned len,
  471.                          unsigned iRow, cfVector X );
  472. void   __vf  MCFCol_divrV( cfPMatrix MA, unsigned ht, unsigned len,
  473.                          unsigned iCol, cfVector X );
  474. void   __vf  MCFDia_divrV( cfPMatrix MA, unsigned len, cfVector X );
  475.  
  476.  
  477. /******  One-dimensional vector operations **********************
  478.          performed along all rows or all columns simultaneously,
  479.          or along the diagonal of a square matrix                */
  480.  
  481. void     __vf  MCFRows_absmax( fVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  482. void     __vf  MCFCols_absmax( fVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  483. float    __vf  MCFDia_absmax(  cfPMatrix MA, unsigned len );
  484. void     __vf  MCFRows_absmin( fVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  485. void     __vf  MCFCols_absmin( fVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  486. float    __vf  MCFDia_absmin(  cfPMatrix MA, unsigned len );
  487.  
  488. void     __vf  MCFRows_maxReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  489. void     __vf  MCFCols_maxReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  490. void     __vf  MCFRows_minReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  491. void     __vf  MCFCols_minReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  492.  
  493. void     __vf  MCFRows_absmaxReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  494. void     __vf  MCFCols_absmaxReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  495. void     __vf  MCFRows_absminReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  496. void     __vf  MCFCols_absminReIm( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  497.  
  498. void     __vf  MCFRows_sum( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  499. void     __vf  MCFCols_sum( cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  500. void     __vf  MCFRows_prod(cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  501. void     __vf  MCFCols_prod(cfVector Y, cfPMatrix MA, unsigned ht, unsigned len );
  502. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  503. } // the following functions cannot be extern "C", if fComplex is a class
  504. #endif
  505. fComplex __vf  MCFDia_maxReIm(  cfPMatrix MA, unsigned len );
  506. fComplex __vf  MCFDia_minReIm(  cfPMatrix MA, unsigned len );
  507. fComplex __vf  MCFDia_absmaxReIm(  cfPMatrix MA, unsigned len );
  508. fComplex __vf  MCFDia_absminReIm(  cfPMatrix MA, unsigned len );
  509. fComplex __vf  MCFDia_sum(  cfPMatrix MA, unsigned len );
  510. fComplex __vf  MCFDia_prod( cfPMatrix MA, unsigned len );
  511. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  512. extern "C" {
  513. #endif
  514.  
  515.  
  516. void  __vf  MCFRows_runsum( cfPMatrix MA, unsigned ht, unsigned len );
  517. void  __vf  MCFCols_runsum( cfPMatrix MA, unsigned ht, unsigned len );
  518. void  __vf  MCFRows_runprod( cfPMatrix MA, unsigned ht, unsigned len );
  519. void  __vf  MCFCols_runprod( cfPMatrix MA, unsigned ht, unsigned len );
  520.  
  521. void  __vf  MCFRows_rotate( cfPMatrix MA, unsigned ht, unsigned len, int pos );
  522. void  __vf  MCFCols_rotate( cfPMatrix MA, unsigned ht, unsigned len, int pos );
  523.  
  524. /********  Operations involving two rows or two colums of one matrix  *****/
  525.  
  526. void   __vf  MCFRows_exchange( cfPMatrix MA, unsigned ht, unsigned len,
  527.                               unsigned i1, unsigned i2 );
  528. void   __vf  MCFCols_exchange( cfPMatrix MA, unsigned ht, unsigned len,
  529.                               unsigned i1, unsigned i2 );
  530.  
  531. void   __vf  MCFRows_add( cfPMatrix MA, unsigned ht, unsigned len,
  532.                           unsigned destRow, unsigned sourceRow );
  533. void   __vf  MCFCols_add( cfPMatrix MA, unsigned ht, unsigned len,
  534.                           unsigned destCol, unsigned sourceCol );
  535.  
  536. void   __vf  MCFRows_sub( cfPMatrix MA, unsigned ht, unsigned len,
  537.                           unsigned destRow, unsigned sourceRow );
  538. void   __vf  MCFCols_sub( cfPMatrix MA, unsigned ht, unsigned len,
  539.                           unsigned destCol, unsigned sourceCol );
  540.  
  541. void   __vf  MCFRows_Cadd( cfPMatrix MA, unsigned ht, unsigned len,
  542.                            unsigned destRow, unsigned sourceRow, fComplex C );
  543. void   __vf  MCFCols_Cadd( cfPMatrix MA, unsigned ht, unsigned len,
  544.                            unsigned destCol, unsigned sourceCol, fComplex C );
  545.  
  546. void   __vf  MCFRows_lincomb( cfPMatrix MA, unsigned ht, unsigned len,
  547.                               unsigned destRow,  fComplex  destC,
  548.                               unsigned srceRow,  fComplex  srceC );
  549. void   __vf  MCFCols_lincomb( cfPMatrix MA, unsigned ht, unsigned len,
  550.                               unsigned destCol,  fComplex  destC,
  551.                               unsigned srceCol,  fComplex  srceC );
  552.  
  553.  
  554. /*************************  Transposing a matrix **********************/
  555.  
  556. void  __vf  MCFtranspose( cfPMatrix MTr, cfPMatrix MA,
  557.                           unsigned htTr, unsigned lenTr );
  558.  
  559.  
  560. /************************ Matrix Multiplication *************************/
  561.  
  562. void  __vf  MCFmulV( cfVector Y, cfPMatrix MA, cfVector X,
  563.                      unsigned htA, unsigned lenA );
  564. void  __vf  VCFmulM( cfVector Y, cfVector X, cfPMatrix MA,
  565.                      unsigned sizX, unsigned lenA );
  566. void  __vf  MCFmulM( cfPMatrix MC, cfPMatrix MA, cfPMatrix MB,
  567.                      unsigned htA, unsigned lenA, unsigned lenB );
  568.  
  569. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  570.  
  571. void  __vf   MCFlFFT( cfPMatrix MY, cfPMatrix MX,
  572.                       unsigned ht, unsigned len, int dir );
  573. void  __vf   MCFlfilter( cfPMatrix MY, cfPMatrix MX, cfPMatrix MFlt,
  574.                          unsigned ht, unsigned len );
  575. void  __vf   MCFsFFT( cfPMatrix MY, cfPMatrix MX,
  576.                       unsigned ht, unsigned len, int dir );
  577. void  __vf   MCFsfilter( cfPMatrix MY, cfPMatrix MX, cfPMatrix MFlt,
  578.                          unsigned ht, unsigned len );
  579.  
  580.       /*************  Input and Output  ****************/
  581.  
  582. void __vf MCFfprint( FILE _VFAR *stream, cfPMatrix MA, unsigned ht,
  583.                      unsigned len, unsigned linewidth );
  584. void __vf MCFcprint( cfPMatrix MA, unsigned ht, unsigned len );
  585. void  __vf    MCFwrite( FILE _VFAR *stream, cfPMatrix X, unsigned ht, unsigned len  );
  586. void  __vf    MCFread( cfPMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  587.  
  588. #ifdef __cplusplus
  589. }
  590. #endif